package cn.tedu.csmall.product.service.impl;

import cn.tedu.csmall.commons.pojo.vo.PageData;
import cn.tedu.csmall.product.ex.ServiceException;
import cn.tedu.csmall.product.mapper.AttributeTemplateMapper;
import cn.tedu.csmall.product.mapper.CategoryAttributeTemplateMapper;
import cn.tedu.csmall.product.mapper.SKUMapper;
import cn.tedu.csmall.product.mapper.SPUMapper;
import cn.tedu.csmall.product.pojo.entity.*;
import cn.tedu.csmall.product.pojo.param.AttributeTemplateAddNewParam;
import cn.tedu.csmall.product.pojo.param.AttributeTemplateUpdateInfoParam;
import cn.tedu.csmall.product.pojo.vo.AttributeTemplateListItemVO;
import cn.tedu.csmall.product.pojo.vo.AttributeTemplateStandardVO;
import cn.tedu.csmall.product.service.AttributeTemplateService;
import cn.tedu.csmall.commons.util.PageInfoToPageDataConverter;
import cn.tedu.csmall.product.web.ServiceCode;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;
import java.util.List;

@Slf4j
@Service
public class AttributeTemplateServiceImpl implements AttributeTemplateService {
    
    @Autowired
    private AttributeTemplateMapper attributeTemplateMapper;
    @Autowired
    private CategoryAttributeTemplateMapper categoryAttributeTemplateMapper;
    @Autowired
    private SPUMapper spuMapper;
    @Autowired
    private SKUMapper skuMapper;
    
    @Override
    public void addNew(AttributeTemplateAddNewParam attributeTemplateAddNewParam) {
        // 检测属性模板名称是否被占用，如果占用，则抛出异常
        QueryWrapper<AttributeTemplate> queryWrapper = new QueryWrapper<>();
        // wrapper中匹配数据库中“name”字段=参数中的值
        queryWrapper.eq("name",attributeTemplateAddNewParam.getName());
        int countByName = attributeTemplateMapper.selectCount(queryWrapper);
        if (countByName > 0) {
            String message = "【ServiceException:添加属性模板失败，属性模板名称已经被占用！】";
            log.debug("【log.info:添加属性模板失败，属性模板名称已经被占用！】");
            throw new ServiceException(ServiceCode.ERR_CONFLICT, message);

        }

        // 将属性模板数据数据写入数据库中
        AttributeTemplate attributeTemplate = new AttributeTemplate();
        BeanUtils.copyProperties(attributeTemplateAddNewParam,attributeTemplate);
        attributeTemplate.setGmtCreate(LocalDateTime.now());
        attributeTemplate.setGmtModified(LocalDateTime.now());
        int rows = attributeTemplateMapper.insert(attributeTemplate);
        if (rows != 1) {
            String msg = "添加属性模板失败，服务器忙，请稍后再试！";
            log.warn(msg);
            // 抛出异常就能回滚
            throw new ServiceException(ServiceCode.ERR_INSERT, msg);
        }
    }

    @Override
    public void deleteById(Long attributeTemplateId) {
        QueryWrapper<AttributeTemplate> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("id",attributeTemplateId);
        int countByName = attributeTemplateMapper.selectCount(queryWrapper);
        if (countByName > 0) {

            // 检查是否有类别（pms_category_attribute_template）关联到了此属性模板，如果有，则不能删除该相册
            QueryWrapper<CategoryAttributeTemplate> categoryAttributeTemplateQueryWrapper = new QueryWrapper<>();
            categoryAttributeTemplateQueryWrapper.eq("attribute_template_id",attributeTemplateId);
            int countByAttributeTemplateId1 = categoryAttributeTemplateMapper.selectCount(categoryAttributeTemplateQueryWrapper);
            if (countByAttributeTemplateId1 > 0) {
                throw new ServiceException(ServiceCode.ERR_CONFLICT, "该属性模板有附属类别，请转移后删除！");
            }

            // 检查是否有SPU关联到了此属性模板，如果有，则不能删除该相册
            QueryWrapper<SPU> spuQueryWrapper = new QueryWrapper<>();
            spuQueryWrapper.eq("attribute_template_id",attributeTemplateId);
            int countByAttributeTemplateId2 = spuMapper.selectCount(spuQueryWrapper);
            if (countByAttributeTemplateId2 > 0) {
                throw new ServiceException(ServiceCode.ERR_CONFLICT, "该属性模板有附属SPU，请转移后删除！");
            }

            // 检查是否有SKU关联到了此属性模板，如果有，则不能删除该相册
            QueryWrapper<SKU> skuQueryWrapper = new QueryWrapper<>();
            skuQueryWrapper.eq("attribute_template_id",attributeTemplateId);
            int countByAttributeTemplateId3 = skuMapper.selectCount(skuQueryWrapper);
            if (countByAttributeTemplateId3 > 0) {
                throw new ServiceException(ServiceCode.ERR_CONFLICT, "该属性模板有附属SKU，请转移后删除！");
            }

            // 不会抛出异常（即该属性模板没有附属的东西），则允许删除
            int rows = attributeTemplateMapper.deleteById(attributeTemplateId);
            if (rows != 1) {
                String msg = "删除属性模板失败，服务器忙，请稍后再试！";
                log.warn(msg);
                // 抛出异常就能回滚
                throw new ServiceException(ServiceCode.ERR_DELETE, msg);
            }
            return;
        }
        String message = "【ServiceException:删除失败，没有该属性模板ID！】";
        log.debug("【log.info:删除失败，没有该属性模板ID！！】");
        throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
    }

    @Override
    public void updateInfoById(Long id, AttributeTemplateUpdateInfoParam attributeTemplateUpdateInfoParam) {

        // 修改前判断数据是否存在
        QueryWrapper<AttributeTemplate> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("id",id);
        int countById = attributeTemplateMapper.selectCount(queryWrapper);
        if (countById == 0) {
            String message = "【ServiceException:修改属性模板失败，没有该属性模板！】";
            log.debug("【log.info:修改属性模板失败，没有该属性模板！】");
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
        }

        // 修改前判断相册名称是否被其他相册占用，如果占用则抛出异常
        QueryWrapper<AttributeTemplate> queryWrapper2 = new QueryWrapper<>();
        queryWrapper2.eq("name",attributeTemplateUpdateInfoParam.getName())// name == name
                .ne("id",id);// id != id
        int countByName = attributeTemplateMapper.selectCount(queryWrapper2);
        if (countByName > 0) {
            String message = "【ServiceException:修改属性模板失败，名称被占用！】";
            log.debug("【log.info:修改属性模板失败，名称被占用！】");
            throw new ServiceException(ServiceCode.ERR_CONFLICT, message);
        }

        // 执行修改
        log.debug("开始处理【修改属性模板详情】的业务，参数：{}",attributeTemplateUpdateInfoParam);
        AttributeTemplate attributeTemplate = new AttributeTemplate();
        BeanUtils.copyProperties(attributeTemplateUpdateInfoParam,attributeTemplate);
        attributeTemplate.setId(id);
        attributeTemplate.setGmtModified(LocalDateTime.now());
        int rows = attributeTemplateMapper.updateById(attributeTemplate);
        if (rows != 1) {
            String msg = "更新属性模板失败，服务器忙，请稍后再试！";
            log.warn(msg);
            // 抛出异常就能回滚
            throw new ServiceException(ServiceCode.ERR_UPDATE, msg);
        }
        log.debug("新的属性模板数据更新到数据库完成！");
    }

    @Override
    public PageData<AttributeTemplateListItemVO> list(Integer pageNum) {
        Integer pageSize = 5;
        return list(pageNum,pageSize);
    }

    @Override
    public PageData<AttributeTemplateListItemVO> list(Integer pageNum, Integer pageSize) {
        log.debug("开始处理【分页查询属性模板列表】的业务，页码：{}，每页记录数：{}", pageNum, pageSize);
        // PageHelper框架的用法，这两句需要一起
        PageHelper.startPage(pageNum,pageSize);
        List<AttributeTemplateListItemVO> list = attributeTemplateMapper.list();
        // 基于查询结果创建PageInfo对象，此对象中包括大量分页查询时的参数
        PageInfo<AttributeTemplateListItemVO> pageInfo = new PageInfo<>(list);
        // pageInfo --> pageData
        return PageInfoToPageDataConverter.convert(pageInfo);
    }

    @Override
    public AttributeTemplateStandardVO getStandardById(Long id) {
        log.debug("开始处理【根据ID查询属性模板】的业务，ID值为：{}", id);
        AttributeTemplateStandardVO result = attributeTemplateMapper.getStandardById(id);
        if (result == null) {
            log.debug("【根据ID查询属性模板】失败，属性模板数据不存在！");
            String message = "【ServiceException:【根据ID查询属性模板】失败，属性模板数据不存在！】";
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
        }
        return result;
    }
}
